// use std::mem;

// use std::thread;

// struct Point<T> {
//     x: T,
//     y: T,
// }

// impl<T: Clone + std::cmp::PartialOrd> Point<T> {
//     fn largest(&self) -> T {
//         if self.x > self.y {
//             self.x.clone()
//         } else {
//             self.y.clone()
//         }
//     }
// }

// impl Point<f32> {
//     fn distance_from_origin(&self) -> f32 {
//         (self.x.powi(2) + self.y.powi(2)).sqrt()
//     }
// }

// enum List {
//     Cons(i32, Box<List>),
//     Nil,
// }

// use std::rc::Rc;

// enum List {
//     Cons(i32, Rc<List>),
//     Nil,
// }

// use std::{time::{SystemTime, Duration}, thread::sleep};

// fn main() -> Result<(), Box<dyn std::error::Error> {
//     let f = std::fs::read("/tmp/not_exist")?;
//     Ok(())
fn main() {
    // assert_eq!(avg(10, 6), 8);
    // println!("pass")
    // let a: i8 = "127".parse::<i8>().unwrap();
    // let b: i8 = 1;
    // let (sum, is_overflow) = a.overflowing_add(b);
    // println!("sum={:?}, is_overflow={:?}", sum, is_overflow);
    // let a: i8 = -10;
    // let b: u8 = a as u8;
    // println!("{}", b)
    // unsafe {
    //     let a = [0u8, 1u8, 0u8, 0u8];
    //     let b: u32 = mem::transmute(a);
    //     println!("{}", b);
    // }
    // let msg = "hello";
    // thread::spawn(move || {
    //     println!("{}", msg)
    // }).join();
    // let point = Point { x: 10, y: 20 };
    // println!("{:?}", point.largest());
    // let point: Point<f32> = Point {x: 3.2, y: 2.8};
    // println!("{:?}", point.distance_from_origin());
    // let list = List::Cons(
    //     0,
    //     Box::new(List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))))),
    // );
    // let a = [0; 1024 * 512];
    // let a = Box::new(a);
    // let four = Rc::new(List::Cons(4, Rc::new(List::Nil)));
    // let zero_one = List::Cons(0, Rc::new(List::Cons(1, Rc::clone(&four))));
    // let two_three = List::Cons(2, Rc::new(List::Cons(3, four)));
    // let now = SystemTime::now();
    // let timestamp = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
    // sleep(Duration::from_secs(2));
    // println!("{:?}", now.elapsed().unwrap());
    // let future = now.checked_add(Duration::from_secs(60));
}

// fn avg(a: u32, b: u32) -> u32 {
//     (a & b) + ((a ^ b) >> 1)
// }
